// wordFetcherDirect.js - 单词信息获取工具（不使用 worker 线程）

/**
 * 单词信息获取类
 * 直接在主线程中处理单词信息的获取
 */
class WordFetcherDirect {
  constructor() {
    this.callbacks = {
      onProgress: null,
      onComplete: null,
      onError: null
    };
    this.isProcessing = false;
    this.abortController = null;
  }

  /**
   * 获取单词详情
   * @param {Array} words - 单词数组
   * @param {Object} options - 配置选项
   * @param {Function} options.onProgress - 进度回调函数
   * @param {Function} options.onComplete - 完成回调函数
   * @param {Function} options.onError - 错误回调函数
   */
  fetchWordDetails(words, options = {}) {
    // 如果已经在处理中，返回错误
    if (this.isProcessing) {
      if (options.onError) {
        options.onError(new Error('已有单词处理任务正在进行中'));
      }
      return;
    }

    // 保存回调函数
    this.callbacks = {
      onProgress: options.onProgress || null,
      onComplete: options.onComplete || null,
      onError: options.onError || null
    };

    // 设置处理状态
    this.isProcessing = true;
    this.shouldAbort = false;

    // 开始处理单词
    this.processWords(words)
      .then(results => {
        if (this.callbacks.onComplete) {
          this.callbacks.onComplete(results);
        }
      })
      .catch(error => {
        console.error('处理单词出错:', error);
        if (this.callbacks.onError) {
          this.callbacks.onError(error);
        }
      })
      .finally(() => {
        this.isProcessing = false;
        this.shouldAbort = false;
      });
  }

  /**
   * 处理单词列表，获取每个单词的详细信息
   * @param {Array} words - 单词数组
   * @returns {Promise<Array>} 处理后的单词数组
   */
  async processWords(words) {
    const results = [];
    let processedCount = 0;
    const totalCount = words.length;
    
    // 遍历单词数组，获取每个单词的详细信息
    for (const word of words) {
      try {
        // 检查是否已中止
        if (this.shouldAbort) {
          throw new Error('操作已被中止');
        }

        // 获取单词详情 - 确保使用单词的英文字符串
        const wordText = typeof word.english === 'string' ? word.english : String(word.english);
        const wordInfo = await this.fetchSingleWordDetails(wordText);
        
        // 合并原始单词数据和获取的详细信息
        const enrichedWord = {
          ...word,
          ...wordInfo
        };
        
        results.push(enrichedWord);
        processedCount++;
        
        // 发送进度更新
        if (this.callbacks.onProgress) {
          this.callbacks.onProgress({
            type: 'progress',
            progress: Math.round((processedCount / totalCount) * 100),
            processed: processedCount,
            total: totalCount
          });
        }
      } catch (error) {
        console.error(`获取单词${word.english}信息失败:`, error);
        // 即使失败也将原始单词加入结果
        results.push(word);
        processedCount++;
        
        // 发送进度更新
        if (this.callbacks.onProgress) {
          this.callbacks.onProgress({
            type: 'progress',
            progress: Math.round((processedCount / totalCount) * 100),
            processed: processedCount,
            total: totalCount,
            error: error.message
          });
        }
      }
      
      // 优化: 仅在处理大量单词时才添加延迟，并减少延迟时间
      // 控制请求频率，避免API限制
      if (processedCount < totalCount && totalCount > 5) {
        // 随着处理数量增加，逐渐减少延迟时间
        const adjustedDelay = Math.max(100, 500 - (processedCount * 20));
        await new Promise(resolve => setTimeout(resolve, adjustedDelay));
      }
    }
    
    return results;
  }

  /**
   * 获取单个单词的详细信息
   * @param {string} word - 单词
   * @returns {Promise<Object>} 单词详细信息
   */
  async fetchSingleWordDetails(word) {
    try {
      // 确保 word 是字符串
      if (typeof word !== 'string') {
        console.error('单词参数类型错误:', word);
        throw new Error('单词参数必须是字符串');
      }
      
      // 使用有道词典API获取单词详细信息
      const apiResult = await this.requestWordDataFromYoudao(word);
      return this.parseYoudaoApiResult(apiResult);
    } catch (error) {
      console.error('获取单词详情失败:', error);
      
      // 如果有道API失败，尝试使用其他备用API
      // try {
      //   const backupApiResult = await this.requestWordDataFromCambridge(word);
      //   return this.parseCambridgeApiResult(backupApiResult);
      // } catch (secondError) {
      //   console.error('备用API也失败:', secondError);
      //   throw new Error('获取单词信息失败');
      // }
    }
  }

  /**
   * 从有道词典API请求单词数据
   * @param {string} word - 单词
   * @returns {Promise<Object>} API响应结果
   */
  requestWordDataFromYoudao(word) {
    return new Promise((resolve, reject) => {
      // 确保 word 是字符串并进行编码
      const wordStr = typeof word === 'string' ? word : String(word);
      const url = `https://dict.youdao.com/jsonapi?q=${encodeURIComponent(wordStr)}`;
      
      wx.request({
        url: url,
        method: 'GET',
        header: {
          'Content-Type': 'application/json'
        },
        success: (res) => {
          if (res.statusCode >= 200 && res.statusCode < 300) {
            resolve(res.data);
          } else {
            reject(new Error(`请求失败: ${res.statusCode}`));
          }
        },
        fail: (error) => {
          reject(new Error(`网络请求失败: ${error.errMsg || '未知错误'}`));
        }
      });
    });
  }

  /**
   * 从剑桥词典API请求单词数据（备用）
   * @param {string} word - 单词
   * @returns {Promise<Object>} API响应结果
   */
  requestWordDataFromCambridge(word) {
    return new Promise((resolve, reject) => {
      const url = `https://dictionary.cambridge.org/api/v1/dictionaries/english-chinese-simplified/entries/${encodeURIComponent(word)}`;
      
      wx.request({
        url: url,
        method: 'GET',
        header: {
          'Content-Type': 'application/json'
          // 实际应用中可能需要添加认证信息
        },
        success: (res) => {
          if (res.statusCode >= 200 && res.statusCode < 300) {
            resolve(res.data);
          } else {
            reject(new Error(`请求失败: ${res.statusCode}`));
          }
        },
        fail: (error) => {
          reject(new Error(`网络请求失败: ${error.errMsg || '未知错误'}`));
        }
      });
    });
  }

  /**
   * 解析有道词典API的响应结果
   * @param {Object} data - API响应数据
   * @returns {Object} 格式化后的单词信息
   */
  parseYoudaoApiResult(data) {
    const result = {
      pronunciation: {
        uk: '',
        us: '',
        audio: {
          uk: '',
          us: ''
        }
      },
      // phrases: [],
      examples: [],
      // synonyms: [],
      // antonyms: [],
      images: [],
      individual: {}
    };
    
    try {
      // 获取单词本身，用于构建发音URL
      const wordText = data.simple?.query || data.input;
      console.log('解析单词:', wordText);
      
      // 解析发音信息
      if (data.simple && data.simple.word) {
        const wordData = data.simple.word[0];
        
        if (wordData.usphone) {
          result.pronunciation.us = `[${wordData.usphone}]`;
          result.pronunciation.audio.us = `https://dict.youdao.com/dictvoice?audio=${encodeURIComponent(wordText)}&type=2`;
        }
        if (wordData.ukphone) {
          result.pronunciation.uk = `[${wordData.ukphone}]`;
          result.pronunciation.audio.uk = `https://dict.youdao.com/dictvoice?audio=${encodeURIComponent(wordText)}&type=1`;
        }
      }
      
      // 从ec字段获取发音信息（备用）
      if ((!result.pronunciation.us || !result.pronunciation.uk) && data.ec && data.ec.word) {
        const ecWordData = data.ec.word[0];
        
        if (!result.pronunciation.us && ecWordData.usphone) {
          result.pronunciation.us = `[${ecWordData.usphone}]`;
          result.pronunciation.audio.us = `https://dict.youdao.com/dictvoice?audio=${encodeURIComponent(wordText)}&type=2`;
        }
        if (!result.pronunciation.uk && ecWordData.ukphone) {
          result.pronunciation.uk = `[${ecWordData.ukphone}]`;
          result.pronunciation.audio.uk = `https://dict.youdao.com/dictvoice?audio=${encodeURIComponent(wordText)}&type=1`;
        }
      }
      
      // 解析例句 - 从blng_sents_part获取
      if (data.blng_sents_part && data.blng_sents_part['sentence-pair']) {
        data.blng_sents_part['sentence-pair'].forEach(pair => {
          if (pair.sentence && pair['sentence-translation']) {
            result.examples.push({
              sentence: pair.sentence,
              translation: pair['sentence-translation']
            });
          }
        });
      }
      
      // 解析词组信息 - 从phrs获取
      // if (data.phrs && data.phrs.phrs) {
      //   data.phrs.phrs.forEach(phrItem => {
      //     if (phrItem.phr && phrItem.phr.headword && phrItem.phr.trs) {
      //       const phrase = phrItem.phr.headword.l.i;
      //       const translations = phrItem.phr.trs.map(tr => tr.tr.l.i).join('; ');
            
      //       result.phrases.push({
      //         phrase: phrase,
      //         translation: translations
      //       });
      //     }
      //   });
      // } else {
      //   delete result.phrases;
      // }
      
      // 尝试获取单词图片 - 从pic_dict获取
      if (data.pic_dict && data.pic_dict.pic) {
        // 将pic_dict中的图片添加到images数组
        result.images = [data.pic_dict.pic[0]];
      }
      
      // 如果没有从pic_dict获取到图片，尝试从video_sents获取
      // if (result.images.length === 0 && data.video_sents && data.video_sents.sents_data && data.video_sents.sents_data.length > 0) {
      //   // 使用第一个视频的封面作为单词图片
      //   const firstVideo = data.video_sents.sents_data[0];
      //   if (firstVideo.video_cover) {
      //     result.images.push(firstVideo.video_cover);
      //   }
      // }

      console.log('原始数据:', data);
      /*
      * 解析个性化数据，包括：
      * 翻译（trs）、习惯用法（idiomatic）、考试信息（examInfo）、相关考题（pastExamSents）、
      * 记忆法（mnemonic）、derivative（derivative）、辨别(discriminate)、近义词(synonym)
      */
      if(data.individual) {
        result.individual = {
          trs: data.individual.trs || undefined,
          idiomatic: data.individual.idiomatic || undefined,
          mnemonic: data.individual.mnemonic || undefined
        };
      }
      
      console.log('解析结果:', result);
    } catch (error) {
      console.error('解析有道API结果失败:', error);
    }
    
    return result;
  }

  /**
   * 解析剑桥词典API的响应结果
   * @param {Object} data - API响应数据
   * @returns {Object} 格式化后的单词信息
   */
  parseCambridgeApiResult(data) {
    const result = {
      pronunciation: {
        uk: '',
        us: '',
        audio: {
          uk: '',
          us: ''
        }
      },
      phrases: [],
      examples: [],
      // synonyms: [],
      // antonyms: [],
      images: []
    };
    
    try {
      // 解析剑桥词典API结果
      // 注意：这里的解析逻辑需要根据实际API响应格式调整
      if (data.result) {
        // 解析发音
        if (data.result.pronunciation) {
          if (data.result.pronunciation.uk) {
            result.pronunciation.uk = `[${data.result.pronunciation.uk}]`;
            result.pronunciation.audio.uk = data.result.pronunciation.ukAudio || '';
          }
          if (data.result.pronunciation.us) {
            result.pronunciation.us = `[${data.result.pronunciation.us}]`;
            result.pronunciation.audio.us = data.result.pronunciation.usAudio || '';
          }
        }
        
        // 解析例句
        if (data.result.examples && Array.isArray(data.result.examples)) {
          data.result.examples.forEach(example => {
            result.examples.push({
              sentence: example.text || '',
              translation: example.translation || ''
            });
          });
        }
        
        // 解析词组
        if (data.result.phrases && Array.isArray(data.result.phrases)) {
          data.result.phrases.forEach(phrase => {
            result.phrases.push({
              phrase: phrase.text || '',
              translation: phrase.translation || ''
            });
          });
        }
      }
    } catch (error) {
      console.error('解析剑桥API结果失败:', error);
    }
    
    return result;
  }

  /**
   * 取消当前的单词处理任务
   */
  cancel() {
    this.shouldAbort = true;
  }
}

// 导出类和单例
module.exports = {
  WordFetcherDirect,
  instance: new WordFetcherDirect()
};